import CryptoJS from 'crypto-js'

// 翻译服务
class TranslationService {
  constructor() {
    this.cache = new Map() // 翻译缓存
    this.currentProvider = 'free' // 默认使用免费翻译API（支持CORS）
    this.apiKeys = {
      baidu: {
        appId: '20250627002391301',
        appKey: 'ZPM1rdKh_etnWFatwYR0'
      },
      tencent: {
        secretId: '你的腾讯云SecretId',
        secretKey: '你的腾讯云SecretKey'
      },
      google: {
        apiKey: '你的Google翻译API密钥'
      }
    }
    this.debugMode = true // 开启调试模式
  }

  // 生成缓存键
  getCacheKey(text, targetLang, sourceLang = 'zh') {
    return `${sourceLang}-${targetLang}-${text}`
  }

  // 百度翻译API
  async translateWithBaidu(text, targetLang, sourceLang = 'zh') {
    const { appId, appKey } = this.apiKeys.baidu
    const salt = Date.now().toString()
    const query = text
    const from = this.getBaiduLangCode(sourceLang)
    const to = this.getBaiduLangCode(targetLang)
    
    // 生成MD5签名
    const sign = CryptoJS.MD5(appId + query + salt + appKey).toString()
    
    const url = 'https://fanyi-api.baidu.com/api/trans/vip/translate'
    const params = new URLSearchParams({
      q: query,
      from,
      to,
      appid: appId,
      salt,
      sign
    })

    try {
      if (this.debugMode) {
        console.log('百度翻译请求:', { query, from, to, appId, salt, sign })
      }
      
      const response = await fetch(`${url}?${params}`, {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json'
        }
      })
      
      const data = await response.json()
      
      if (this.debugMode) {
        console.log('百度翻译响应:', data)
      }
      
      if (data.trans_result && data.trans_result.length > 0) {
        return data.trans_result[0].dst
      }
      
      if (data.error_code) {
        console.warn('百度翻译错误:', data.error_code, data.error_msg)
        // 根据错误码处理
        if (data.error_code === '52001') {
          throw new Error('请求超时，请重试')
        } else if (data.error_code === '52002') {
          throw new Error('系统错误，请重试')
        } else if (data.error_code === '52003') {
          throw new Error('未授权用户')
        } else if (data.error_code === '54001') {
          throw new Error('签名错误')
        } else if (data.error_code === '54003') {
          throw new Error('访问频率受限')
        } else if (data.error_code === '54004') {
          throw new Error('账户余额不足')
        } else if (data.error_code === '54005') {
          throw new Error('长query请求频繁')
        } else if (data.error_code === '58000') {
          throw new Error('客户端IP非法')
        } else if (data.error_code === '58001') {
          throw new Error('译文语言方向不支持')
        } else if (data.error_code === '58002') {
          throw new Error('服务当前已关闭')
        } else if (data.error_code === '90107') {
          throw new Error('认证未通过或未生效')
        }
      }
      
      throw new Error('百度翻译失败')
    } catch (error) {
      console.error('百度翻译错误:', error)
      throw error
    }
  }

  // Google翻译API（使用免费代理）
  async translateWithGoogle(text, targetLang, sourceLang = 'zh') {
    const url = `https://translate.googleapis.com/translate_a/single?client=gtx&sl=${sourceLang}&tl=${targetLang}&dt=t&q=${encodeURIComponent(text)}`
    
    try {
      const response = await fetch(url, {
        headers: {
          'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
      })
      
      const data = await response.json()
      
      if (data && data[0] && data[0][0] && data[0][0][0]) {
        return data[0][0][0]
      }
      throw new Error('Google翻译失败')
    } catch (error) {
      console.error('Google翻译错误:', error)
      throw error
    }
  }

  // 免费翻译API
  async translateWithFree(text, targetLang, sourceLang = 'zh') {
    // 首先尝试使用MyMemory API（最稳定）
    try {
      if (this.debugMode) {
        console.log('尝试使用MyMemory API翻译...')
      }
      
      const myMemoryUrl = `https://api.mymemory.translated.net/get?q=${encodeURIComponent(text)}&langpair=${sourceLang}|${targetLang}`
      const response = await fetch(myMemoryUrl)
      
      if (!response.ok) {
        throw new Error(`MyMemory API HTTP错误: ${response.status}`)
      }
      
      const data = await response.json()
      
      if (data.responseData && data.responseData.translatedText) {
        const result = data.responseData.translatedText
        if (this.debugMode) {
          console.log('MyMemory API翻译成功:', result)
        }
        return result
      }
      
      throw new Error('MyMemory API响应格式错误')
    } catch (error) {
      console.error('MyMemory API翻译失败:', error)
    }

    // 如果MyMemory失败，尝试使用LibreTranslate
    try {
      if (this.debugMode) {
        console.log('尝试使用LibreTranslate API翻译...')
      }
      
      const libreUrl = 'https://libretranslate.de/translate'
      const response = await fetch(libreUrl, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          q: text,
          source: sourceLang,
          target: targetLang,
          format: 'text'
        })
      })
      
      if (!response.ok) {
        throw new Error(`LibreTranslate HTTP错误: ${response.status}`)
      }
      
      const data = await response.json()
      
      if (data.translatedText) {
        if (this.debugMode) {
          console.log('LibreTranslate API翻译成功:', data.translatedText)
        }
        return data.translatedText
      }
      
      throw new Error('LibreTranslate API响应格式错误')
    } catch (error) {
      console.error('LibreTranslate API翻译失败:', error)
    }

    // 如果都失败了，尝试使用Google翻译免费接口
    try {
      if (this.debugMode) {
        console.log('尝试使用Google翻译免费接口...')
      }
      
      return await this.translateWithGoogle(text, targetLang, sourceLang)
    } catch (error) {
      console.error('Google翻译免费接口也失败:', error)
    }

    // 最后的后备方案：返回原文并提示
    console.warn('所有翻译服务都不可用，返回原文')
    return text
  }

  // 主要翻译方法
  async translate(text, targetLang, sourceLang = 'zh') {
    // 如果目标语言和源语言相同，直接返回
    if (targetLang === sourceLang) {
      return text
    }

    // 如果文本为空，直接返回
    if (!text || text.trim() === '') {
      return text
    }

    // 检查缓存
    const cacheKey = this.getCacheKey(text, targetLang, sourceLang)
    if (this.cache.has(cacheKey)) {
      if (this.debugMode) {
        console.log(`从缓存获取翻译: "${text}" -> "${this.cache.get(cacheKey)}"`)
      }
      return this.cache.get(cacheKey)
    }

    let translatedText = text

    try {
      // 根据当前提供商选择翻译服务
      if (this.currentProvider === 'baidu' && this.apiKeys.baidu.appId !== '你的百度翻译APPID') {
        if (this.debugMode) {
          console.log('使用百度翻译API（注意：可能因CORS限制失败）')
        }
        translatedText = await this.translateWithBaidu(text, targetLang, sourceLang)
      } else if (this.currentProvider === 'google') {
        if (this.debugMode) {
          console.log('使用Google翻译免费接口')
        }
        translatedText = await this.translateWithGoogle(text, targetLang, sourceLang)
      } else {
        if (this.debugMode) {
          console.log('使用免费翻译API（推荐）')
        }
        translatedText = await this.translateWithFree(text, targetLang, sourceLang)
      }
      
    } catch (error) {
      console.error(`${this.currentProvider}翻译服务错误:`, error)
      
      // 智能降级策略
      if (this.currentProvider === 'baidu') {
        console.log('百度翻译失败（可能是CORS限制），切换到免费翻译服务')
        try {
          translatedText = await this.translateWithFree(text, targetLang, sourceLang)
        } catch (freeError) {
          console.log('免费翻译服务也失败，尝试Google翻译')
          try {
            translatedText = await this.translateWithGoogle(text, targetLang, sourceLang)
          } catch (googleError) {
            console.error('所有翻译服务都失败，返回原文')
            translatedText = text
          }
        }
      } else if (this.currentProvider === 'google') {
        console.log('Google翻译失败，切换到免费翻译服务')
        try {
          translatedText = await this.translateWithFree(text, targetLang, sourceLang)
        } catch (freeError) {
          console.error('免费翻译服务也失败，返回原文')
          translatedText = text
        }
      } else {
        // 免费服务失败的情况下，已经在translateWithFree中处理了所有后备方案
        translatedText = text
      }
    }

    // 缓存翻译结果
    this.cache.set(cacheKey, translatedText)
    
    if (this.debugMode) {
      console.log(`翻译完成: "${text}" -> "${translatedText}" (${sourceLang} -> ${targetLang})`)
    }
    
    return translatedText
  }

  // 批量翻译
  async translateBatch(texts, targetLang, sourceLang = 'zh') {
    const promises = texts.map(text => this.translate(text, targetLang, sourceLang))
    return await Promise.all(promises)
  }

  // 获取百度翻译语言代码
  getBaiduLangCode(lang) {
    const langMap = {
      'zh': 'zh',
      'en': 'en',
      'pt': 'pt'
    }
    return langMap[lang] || lang
  }

  // 清除缓存
  clearCache() {
    this.cache.clear()
  }

  // 设置API密钥
  setApiKey(provider, credentials) {
    this.apiKeys[provider] = { ...this.apiKeys[provider], ...credentials }
  }

  // 切换翻译提供商
  setProvider(provider) {
    this.currentProvider = provider
    if (this.debugMode) {
      console.log(`翻译提供商已切换到: ${provider}`)
    }
  }

  // 切换翻译提供商（别名方法）
  switchProvider(provider) {
    this.setProvider(provider)
  }

  // 设置调试模式
  setDebugMode(enabled) {
    this.debugMode = enabled
  }

  // 获取缓存
  getCache() {
    return this.cache
  }

  // 获取统计信息
  getStats() {
    return {
      cacheSize: this.cache.size,
      currentProvider: this.currentProvider,
      debugMode: this.debugMode
    }
  }
}

// 创建全局翻译服务实例
const translationService = new TranslationService()

export default translationService 